<?xml version="1.0"?>
<doc>
    <assembly>
        <name>ReactiveUI.Xaml</name>
    </assembly>
    <members>
        <member name="M:ReactiveUI.Xaml.DependencyPropertyMixin.ObservableFromDP``2(``0,System.Linq.Expressions.Expression{System.Func{``0,``1}})">
            <summary>
            Creates an IObservable from an existing dependency property. Note
            that this method is somewhat expensive and should not be called
            frequently.
            </summary>
            <param name="property">An Expression specifying the property to use
            on the DependencyObject (e.g. x => x.SomeProperty)</param>
            <returns>An Observable that fires whenever the DP changes, and never
            completes.</returns>
        </member>
        <member name="T:ReactiveUI.Xaml.TransitioningContentControl">
            <summary>
            A ContentControl that animates the transition when its content is changed.
            </summary>
        </member>
        <member name="F:ReactiveUI.Xaml.TransitioningContentControl.TransitionProperty">
            <summary>
            <see cref="T:System.Windows.DependencyProperty"/> for the <see cref="P:ReactiveUI.Xaml.TransitioningContentControl.Transition"/> property.
            </summary>
        </member>
        <member name="F:ReactiveUI.Xaml.TransitioningContentControl.TransitionPartProperty">
            <summary>
            <see cref="T:System.Windows.DependencyProperty"/> for the <see cref="P:ReactiveUI.Xaml.TransitioningContentControl.TransitionPart"/> property.
            </summary>
        </member>
        <member name="M:ReactiveUI.Xaml.TransitioningContentControl.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:ReactiveUI.Xaml.TransitioningContentControl"/> class.
            </summary>
        </member>
        <member name="M:ReactiveUI.Xaml.TransitioningContentControl.OnContentChanged(System.Object,System.Object)">
            <summary>
            Called when the value of the <see cref="P:System.Windows.Controls.ContentControl.Content"/> property changes.
            </summary>
            <param name="oldContent">The old value of the <see cref="P:System.Windows.Controls.ContentControl.Content"/> property.</param>
            <param name="newContent">The new value of the <see cref="P:System.Windows.Controls.ContentControl.Content"/> property.</param>
        </member>
        <member name="M:ReactiveUI.Xaml.TransitioningContentControl.AbortTransition">
            <summary>
            Aborts the transition.
            </summary>
        </member>
        <member name="M:ReactiveUI.Xaml.TransitioningContentControl.SetTransitionDefaultValues">
            <summary>
            Sets default values for certain transition types.
            </summary>
        </member>
        <member name="E:ReactiveUI.Xaml.TransitioningContentControl.TransitionCompleted">
            <summary>
            Occurs when a transition has completed.
            </summary>
        </member>
        <member name="E:ReactiveUI.Xaml.TransitioningContentControl.TransitionStarted">
            <summary>
            Occurs when a transition has started.
            </summary>
        </member>
        <member name="P:ReactiveUI.Xaml.TransitioningContentControl.Transition">
            <summary>
            Gets or sets the transition.
            </summary>
            <value>The transition.</value>
        </member>
        <member name="P:ReactiveUI.Xaml.TransitioningContentControl.TransitionPart">
            <summary>
            Gets or sets the transition part.
            </summary>
            <value>The transition part.</value>
        </member>
        <member name="T:ReactiveUI.Xaml.TransitioningContentControl.TransitionType">
            <summary>
            Represents the type of transition that a TransitioningContentControl will perform.
            </summary>
        </member>
        <member name="F:ReactiveUI.Xaml.TransitioningContentControl.TransitionType.Fade">
            <summary>
            A simple fading transition.
            </summary>
        </member>
        <member name="F:ReactiveUI.Xaml.TransitioningContentControl.TransitionType.FadeDown">
            <summary>
            A transition that fades the new element in from the top.
            </summary>
        </member>
        <member name="F:ReactiveUI.Xaml.TransitioningContentControl.TransitionType.SlideLeft">
            <summary>
            A transition that slides old content left and out of view, then slides new content back in from the same direction.
            </summary>
        </member>
        <member name="T:ReactiveUI.Xaml.TransitioningContentControl.TransitionPartType">
            <summary>
            Represents the part of the transition that the developer would like the TransitioningContentControl to perform
            </summary>
            <remarks>This only applies to certain TransitionTypes. An InvalidOperationException will be thrown if the TransitionType does not support the TransitionPartType. Default is OutIn.</remarks>
        </member>
        <member name="F:ReactiveUI.Xaml.TransitioningContentControl.TransitionPartType.Out">
            <summary>
            Transitions out only.
            </summary>
        </member>
        <member name="F:ReactiveUI.Xaml.TransitioningContentControl.TransitionPartType.In">
            <summary>
            Transitions in only.
            </summary>
        </member>
        <member name="F:ReactiveUI.Xaml.TransitioningContentControl.TransitionPartType.OutIn">
            <summary>
            Transitions in and out.
            </summary>
        </member>
        <member name="T:ReactiveUI.Xaml.ReactiveAsyncCommand">
            <summary>
            ReactiveAsyncCommand represents commands that run an asynchronous
            operation in the background when invoked. The main benefit of this
            command is that it will keep track of in-flight operations and
            disable/enable CanExecute when there are too many of them (i.e. a
            "Search" button shouldn't have many concurrent requests running if the
            user clicks the button many times quickly)
            </summary>
        </member>
        <member name="T:ReactiveUI.Xaml.IReactiveAsyncCommand">
            <summary>
            IReactiveAsyncCommand represents commands that run an asynchronous
            operation in the background when invoked.
            </summary>
        </member>
        <member name="T:ReactiveUI.Xaml.IReactiveCommand">
            <summary>
            IReactiveCommand is an Rx-enabled version of ICommand that is also an
            Observable. Its Observable fires once for each invocation of
            ICommand.Execute and its value is the CommandParameter that was
            provided.
            </summary>
        </member>
        <member name="P:ReactiveUI.Xaml.IReactiveCommand.CanExecuteObservable">
            <summary>
            Fires whenever the CanExecute of the ICommand changes. Note that
            this should not fire notifications unless the CanExecute changes
            (i.e. it should not fire 'true', 'true').
            </summary>
        </member>
        <member name="P:ReactiveUI.Xaml.IReactiveAsyncCommand.ItemsInflight">
            <summary>
            Fires whenever the number of asynchronous operations in-flight (i.e.
            currently running) changes and provides the new Count.
            </summary>
        </member>
        <member name="P:ReactiveUI.Xaml.IReactiveAsyncCommand.AsyncStartedNotification">
            <summary>
            Should be fired whenever an async operation starts.
            </summary>
        </member>
        <member name="P:ReactiveUI.Xaml.IReactiveAsyncCommand.AsyncCompletedNotification">
            <summary>
            Should be fired whenever an async operation completes.
            </summary>
        </member>
        <member name="M:ReactiveUI.Xaml.ReactiveAsyncCommand.#ctor(System.IObservable{System.Boolean},System.Int32,System.Reactive.Concurrency.IScheduler)">
            <summary>
            Constructs a new ReactiveAsyncCommand.
            </summary>
            <param name="canExecute">An Observable representing when the command
            can execute. If null, the Command can always execute.</param>
            <param name="maximumConcurrent">The maximum number of in-flight
            operations at a time - defaults to one.</param>
            <param name="scheduler">The scheduler to run the asynchronous
            operations on - defaults to the Taskpool scheduler.</param>
        </member>
        <member name="M:ReactiveUI.Xaml.ReactiveAsyncCommand.Create``1(System.Func{System.Object,``0},System.Action{``0},System.Func{System.Object,System.Boolean},System.Int32,System.Reactive.Concurrency.IScheduler)">
            <summary>
            Create is a helper method to create a basic ReactiveAsyncCommand
            in a non-Rx way, closer to how BackgroundWorker works.
            </summary>
            <param name="calculationFunc">The function that will calculate
            results in the background</param>
            <param name="callbackFunc">The method to be called once the
            calculation function completes. This method is guaranteed to be
            called on the UI thread.</param>
            <param name="maximumConcurrent">The maximum number of in-flight
            operations at a time - defaults to one.</param>
            <param name="scheduler">The scheduler to run the asynchronous
            operations on - defaults to the Taskpool scheduler.</param>
        </member>
        <member name="M:ReactiveUI.Xaml.ReactiveAsyncCommand.RegisterAsyncFunction``1(System.Func{System.Object,``0},System.Reactive.Concurrency.IScheduler)">
            <summary>
            RegisterAsyncFunction registers an asynchronous method that returns a result
            to be called whenever the Command's Execute method is called.
            </summary>
            <param name="calculationFunc">The function to be run in the
            background.</param>
            <param name="scheduler"></param>
            <returns>An Observable that will fire on the UI thread once per
            invoecation of Execute, once the async method completes. Subscribe to
            this to retrieve the result of the calculationFunc.</returns>
        </member>
        <member name="M:ReactiveUI.Xaml.ReactiveAsyncCommand.RegisterAsyncAction(System.Action{System.Object},System.Reactive.Concurrency.IScheduler)">
            <summary>
            RegisterAsyncAction registers an asynchronous method that runs
            whenever the Command's Execute method is called and doesn't return a
            result.
            </summary>
            <param name="calculationFunc">The function to be run in the
            background.</param>
        </member>
        <member name="M:ReactiveUI.Xaml.ReactiveAsyncCommand.RegisterAsyncTask``1(System.Func{System.Object,System.Threading.Tasks.Task{``0}})">
            <summary>
            RegisterAsyncTask registers an TPL/Async method that runs when a 
            Command gets executed and returns the result
            </summary>
            <returns>An Observable that will fire on the UI thread once per
            invoecation of Execute, once the async method completes. Subscribe to
            this to retrieve the result of the calculationFunc.</returns>
        </member>
        <member name="M:ReactiveUI.Xaml.ReactiveAsyncCommand.RegisterAsyncTask``1(System.Func{System.Object,System.Threading.Tasks.Task})">
            <summary>
            RegisterAsyncTask registers an TPL/Async method that runs when a 
            Command gets executed and returns no result. 
            </summary>
            <param name="calculationFunc">The function to be run in the
            background.</param>
            <returns>An Observable that signals when the Task completes, on
            the UI thread.</returns>
        </member>
        <member name="M:ReactiveUI.Xaml.ReactiveAsyncCommand.RegisterAsyncObservable``1(System.Func{System.Object,System.IObservable{``0}})">
            <summary>
            RegisterAsyncObservable registers an Rx-based async method whose
            results will be returned on the UI thread.
            </summary>
            <param name="calculationFunc">A calculation method that returns a
            future result, such as a method returned via
            Observable.FromAsyncPattern.</param>
            <returns>An Observable representing the items returned by the
            calculation result. Note that with this method it is possible with a
            calculationFunc to return multiple items per invocation of Execute.</returns>
        </member>
        <member name="M:ReactiveUI.Xaml.ReactiveAsyncCommand.RegisterMemoizedFunction``1(System.Func{System.Object,``0},System.Int32,System.Action{``0},System.Reactive.Concurrency.IScheduler)">
             <summary>
             RegisterMemoizedFunction is similar to RegisterAsyncFunction, but
             caches its results so that subsequent Execute calls with the same
             CommandParameter will not need to be run in the background.         
             </summary>
             <param name="calculationFunc">The function that performs the
             expensive or asyncronous calculation and returns the result.
            
             Note that this function *must* return an equivalently-same result given a
             specific input - because the function is being memoized, if the
             calculationFunc depends on other varables other than the input
             value, the results will be unpredictable.</param>
             <param name="maxSize">The number of items to cache. When this limit
             is reached, not recently used items will be discarded.</param>
             <param name="onRelease">This optional method is called when an item
             is evicted from the cache - this can be used to clean up / manage an
             on-disk cache; the calculationFunc can download a file and save it
             to a temporary folder, and the onRelease action will delete the
             file.</param>
             <param name="sched">The scheduler to run asynchronous operations on
             - defaults to TaskpoolScheduler</param>
             <returns>An Observable that will fire on the UI thread once per
             invocation of Execute, once the async method completes. Subscribe to
             this to retrieve the result of the calculationFunc.</returns>
        </member>
        <member name="M:ReactiveUI.Xaml.ReactiveAsyncCommand.RegisterMemoizedObservable``1(System.Func{System.Object,System.IObservable{``0}},System.Int32,System.Action{``0},System.Reactive.Concurrency.IScheduler)">
             <summary>
             RegisterMemoizedObservable is similar to RegisterAsyncObservable, but
             caches its results so that subsequent Execute calls with the same
             CommandParameter will not need to be run in the background.         
             </summary>
             <param name="calculationFunc">The function that performs the
             expensive or asyncronous calculation and returns the result.
            
             Note that this function *must* return an equivalently-same result given a
             specific input - because the function is being memoized, if the
             calculationFunc depends on other varables other than the input
             value, the results will be unpredictable. 
             </param>
             <param name="maxSize">The number of items to cache. When this limit
             is reached, not recently used items will be discarded.</param>
             <param name="onRelease">This optional method is called when an item
             is evicted from the cache - this can be used to clean up / manage an
             on-disk cache; the calculationFunc can download a file and save it
             to a temporary folder, and the onRelease action will delete the
             file.</param>
             <param name="sched">The scheduler to run asynchronous operations on
             - defaults to TaskpoolScheduler</param>
             <returns>An Observable representing the items returned by the
             calculation result. Note that with this method it is possible with a
             calculationFunc to return multiple items per invocation of Execute.</returns>
        </member>
        <member name="M:ReactiveUI.Xaml.ReactiveAsyncCommandMixins.CurrentItemsInFlight(ReactiveUI.Xaml.IReactiveAsyncCommand)">
            <summary>
            This method returns the current number of items in flight.
            </summary>
        </member>
        <member name="T:ReactiveUI.Xaml.StockUserErrorIcon">
            <summary>
            Describes a stock error icon situation - it is up to the UI to decide
            how to interpret these icons.
            </summary>
        </member>
        <member name="T:ReactiveUI.Xaml.IRecoveryCommand">
            <summary>
            A command that represents a recovery from an error. These commands
            will typically be displayed as buttons in the error dialog.
            </summary>
        </member>
        <member name="P:ReactiveUI.Xaml.IRecoveryCommand.CommandName">
            <summary>
            The command name, typically displayed as the button text.
            </summary>
        </member>
        <member name="P:ReactiveUI.Xaml.IRecoveryCommand.RecoveryResult">
            <summary>
            When the command is invoked and a result is determined, the
            command should set the recovery result to indicate the action the
            throwing code should take.
            </summary>
        </member>
        <member name="T:ReactiveUI.Xaml.RecoveryOptionResult">
            <summary>
            RecoveryOptionResult describes to the code throwing the UserError what
            to do once the error is resolved.
            </summary>
        </member>
        <member name="F:ReactiveUI.Xaml.RecoveryOptionResult.CancelOperation">
            <summary>
            The operation should be cancelled, but it is no longer an error.
            </summary>
        </member>
        <member name="F:ReactiveUI.Xaml.RecoveryOptionResult.RetryOperation">
            <summary>
            The operation should be retried with the same parameters.
            </summary>
        </member>
        <member name="F:ReactiveUI.Xaml.RecoveryOptionResult.FailOperation">
            <summary>
            Recovery failed or not possible, you should rethrow as an
            Exception.
            </summary>
        </member>
        <member name="T:ReactiveUI.Xaml.UserError">
             <summary>
             User Errors are similar to Exceptions, except that they are intended
             to be displayed to the user. As such, your error messages should be
             phrased in a friendly way. When a UserError is thrown, code higher up
             in the stack has a chance to resolve the UserError via a user
             interaction. 
            
             Code can also add "Recovery Options" which resolve user errors: for
             example an "Out of Disk Space" error might have an "Open Explorer"
             recovery option.
             </summary>
        </member>
        <member name="M:ReactiveUI.Xaml.UserError.Throw(System.String,System.Exception)">
            <summary>
            Initiate a user interaction (i.e. "Throw the error to the user to
            deal with") - this method is the simplest way to prompt the user
            that an error has occurred.
            </summary>
            <param name="errorMessage">The message to show to the user. The
            upper level handlers registered with RegisterHandler are
            ultimately responsible for displaying this information.</param>
            <param name="innerException">The Exception that was thrown, if
            relevant - this will *not* ever be shown to the user.</param>
            <returns>An Observable representing the action the code should
            attempt to take, if any.</returns>
        </member>
        <member name="M:ReactiveUI.Xaml.UserError.Throw(ReactiveUI.Xaml.UserError)">
            <summary>
            Initiate a user interaction (i.e. "Throw the error to the user to
            deal with"). 
            </summary>
            <param name="error">The UserError to show to the user. The
            upper level handlers registered with RegisterHandler are
            ultimately responsible for displaying this information. </param>
            <returns></returns>
        </member>
        <member name="M:ReactiveUI.Xaml.UserError.RegisterHandler(System.Func{ReactiveUI.Xaml.UserError,System.IObservable{ReactiveUI.Xaml.RecoveryOptionResult}})">
             <summary>
             Register code to handle a UserError. Registered handlers are
             called in reverse order to their registration (i.e. the newest
             handler is called first), and they each have a chance to handle a
             UserError. 
            
             If a Handler cannot resolve a UserError, it should return null
             instead of an Observable result.
             </summary>
             <param name="errorHandler">A method that can handle a UserError,
             usually by presenting it to the user. If the handler cannot handle
             the error, it should return null.</param>
             <returns>An IDisposable which will unregister the handler.</returns>
        </member>
        <member name="M:ReactiveUI.Xaml.UserError.RegisterHandler``1(System.Func{``0,System.IObservable{ReactiveUI.Xaml.RecoveryOptionResult}})">
             <summary>
             Register code to handle a specific type of UserError. Registered
             handlers are called in reverse order to their registration (i.e.
             the newest handler is called first), and they each have a chance
             to handle a UserError. 
            
             If a Handler cannot resolve a UserError, it should return null
             instead of an Observable result.
             </summary>
             <param name="errorHandler">A method that can handle a UserError,
             usually by presenting it to the user. If the handler cannot handle
             the error, it should return null.</param>
             <returns>An IDisposable which will unregister the handler.</returns>
        </member>
        <member name="M:ReactiveUI.Xaml.UserError.RegisterHandler(System.Func{ReactiveUI.Xaml.UserError,System.Threading.Tasks.Task{ReactiveUI.Xaml.RecoveryOptionResult}})">
             <summary>
             Register code to handle a UserError. Registered handlers are
             called in reverse order to their registration (i.e. the newest
             handler is called first), and they each have a chance to handle a
             UserError. 
            
             If a Handler cannot resolve a UserError, it should return null
             instead of an Observable result.
             </summary>
             <param name="errorHandler">A method that can handle a UserError,
             usually by presenting it to the user. If the handler cannot handle
             the error, it should return null.</param>
             <returns>An IDisposable which will unregister the handler.</returns>
        </member>
        <member name="M:ReactiveUI.Xaml.UserError.RegisterHandler``1(System.Func{``0,System.Threading.Tasks.Task{ReactiveUI.Xaml.RecoveryOptionResult}})">
             <summary>
             Register code to handle a specific type of UserError. Registered
             handlers are called in reverse order to their registration (i.e.
             the newest handler is called first), and they each have a chance
             to handle a UserError. 
            
             If a Handler cannot resolve a UserError, it should return null
             instead of an Observable result.
             </summary>
             <param name="errorHandler">A method that can handle a UserError,
             usually by presenting it to the user. If the handler cannot handle
             the error, it should return null.</param>
             <returns>An IDisposable which will unregister the handler.</returns>
        </member>
        <member name="M:ReactiveUI.Xaml.UserError.AddRecoveryOption(ReactiveUI.Xaml.IRecoveryCommand,System.Func{ReactiveUI.Xaml.UserError,System.Boolean})">
            <summary>
            This method is a convenience wrapper around RegisterHandler that
            adds the specified RecoveryCommand to any UserErrors that match
            its filter.
            </summary>
            <param name="command">The RecoveryCommand to add.</param>
            <param name="filter">An optional filter to determine which
            UserErrors to add the command to.</param>
            <returns>An IDisposable which will unregister the handler.</returns>
        </member>
        <member name="M:ReactiveUI.Xaml.UserError.OverrideHandlersForTesting(System.Func{ReactiveUI.Xaml.UserError,System.IObservable{ReactiveUI.Xaml.RecoveryOptionResult}})">
            <summary>
            This method replaces *all* UserError handlers with the specified
            handler. Use it for testing code that may throw UserErrors.
            </summary>
            <param name="errorHandler">The replacement UserError handler.</param>
            <returns>An IDisposable which will unregister the test handler.</returns>
        </member>
        <member name="M:ReactiveUI.Xaml.UserError.OverrideHandlersForTesting(System.Func{ReactiveUI.Xaml.UserError,ReactiveUI.Xaml.RecoveryOptionResult})">
            <summary>
            This method replaces *all* UserError handlers with the specified
            handler. Use it for testing code that may throw UserErrors.
            </summary>
            <param name="errorHandler">The replacement UserError handler.</param>
            <returns>An IDisposable which will unregister the test handler.</returns>
        </member>
        <member name="P:ReactiveUI.Xaml.UserError.Domain">
            <summary>
            The component that originally threw the error - if this is not
            supplied, it defaults to the assembly name.
            </summary>
        </member>
        <member name="P:ReactiveUI.Xaml.UserError.ContextInfo">
            <summary>
            A Dictionary that allows UserErrors to contain arbitrary
            application data.
            </summary>
        </member>
        <member name="P:ReactiveUI.Xaml.UserError.RecoveryOptions">
            <summary>
            The list of available Recovery Options that will be presented to
            the user to resolve the issue - these usually correspond to
            buttons in the dialog.
            </summary>
        </member>
        <member name="P:ReactiveUI.Xaml.UserError.ErrorMessage">
            <summary>
            The "Newspaper Headline" of the message being conveyed to the
            user. This should be one line, short, and informative.
            </summary>
        </member>
        <member name="P:ReactiveUI.Xaml.UserError.ErrorCauseOrResolution">
            <summary>
            Additional optional information to describe what is happening, or
            the resolution to an information-only error (i.e. a dialog to tell
            the user that something has happened)
            </summary>
        </member>
        <member name="P:ReactiveUI.Xaml.UserError.UserErrorIcon">
            <summary>
            This object is either a custom icon (usually an ImageSource), or
            it can also be a StockUserErrorIcon. It can also be an
            application-defined type that the handlers know to interpret.
            </summary>
        </member>
        <member name="P:ReactiveUI.Xaml.UserError.InnerException">
            <summary>
            Optionally, The actual Exception that warranted throwing the
            UserError.
            </summary>
        </member>
        <member name="T:ReactiveUI.Xaml.UnhandledUserErrorException">
            <summary>
            This Exception will be thrown when a UserError is not handled by any
            of the registered handlers.
            </summary>
        </member>
        <member name="T:ReactiveUI.Xaml.RecoveryCommand">
            <summary>
            RecoveryCommand is a straightforward implementation of a recovery
            command - this class represents a command presented to the user
            (usually in the form of a button) that will help resolve or mitigate a
            UserError.
            </summary>
        </member>
        <member name="T:ReactiveUI.Xaml.ReactiveCommand">
            <summary>
            IReactiveCommand is an Rx-enabled version of ICommand that is also an
            Observable. Its Observable fires once for each invocation of
            ICommand.Execute and its value is the CommandParameter that was
            provided.
            </summary>
        </member>
        <member name="M:ReactiveUI.Xaml.ReactiveCommand.#ctor(System.IObservable{System.Boolean},System.Reactive.Concurrency.IScheduler)">
            <summary>
            Creates a new ReactiveCommand object.
            </summary>
            <param name="canExecute">An Observable, often obtained via
            ObservableFromProperty, that defines when the Command can
            execute.</param>
            <param name="scheduler">The scheduler to publish events on - default
            is RxApp.DeferredScheduler.</param>
        </member>
        <member name="M:ReactiveUI.Xaml.ReactiveCommand.Create(System.Func{System.Object,System.Boolean},System.Action{System.Object},System.Reactive.Concurrency.IScheduler)">
            <summary>
            Creates a new ReactiveCommand object in an imperative, non-Rx way,
            similar to RelayCommand.
            </summary>
            <param name="canExecute">A function that determines when the Command
            can execute.</param>
            <param name="executed">A method that will be invoked when the
            Execute method is invoked.</param>
            <param name="scheduler">The scheduler to publish events on - default
            is RxApp.DeferredScheduler.</param>
            <returns>A new ReactiveCommand object.</returns>
        </member>
        <member name="M:ReactiveUI.Xaml.ReactiveCommand.Create(System.Func{System.Object,System.Threading.Tasks.Task{System.Boolean}},System.Action{System.Object},System.Reactive.Concurrency.IScheduler)">
            <summary>
            Creates a new ReactiveCommand object in an imperative, non-Rx way,
            similar to RelayCommand, only via a TPL Async method
            </summary>
            <param name="canExecute">A function that determines when the Command
            can execute.</param>
            <param name="executed">A method that will be invoked when the
            Execute method is invoked.</param>
            <param name="scheduler">The scheduler to publish events on - default
            is RxApp.DeferredScheduler.</param>
            <returns>A new ReactiveCommand object.</returns>
        </member>
        <member name="P:ReactiveUI.Xaml.ReactiveCommand.CanExecuteObservable">
            <summary>
            Fires whenever the CanExecute of the ICommand changes. 
            </summary>
        </member>
        <member name="M:ReactiveUI.Xaml.RecoveryCommand.#ctor(System.String,System.Func{System.Object,ReactiveUI.Xaml.RecoveryOptionResult})">
            <summary>
            Constructs a RecoveryCommand.
            </summary>
            <param name="commandName">The user-visible name of this Command.</param>
            <param name="handler">A convenience handler - equivalent to
            Subscribing to the command and setting the RecoveryResult.</param>
        </member>
        <member name="M:ReactiveUI.Xaml.ReactiveCommandMixins.ToCommand(System.IObservable{System.Boolean},System.Reactive.Concurrency.IScheduler)">
            <summary>
            ToCommand is a convenience method for returning a new
            ReactiveCommand based on an existing Observable chain.
            </summary>
            <param name="scheduler">The scheduler to publish events on - default
            is RxApp.DeferredScheduler.</param>
            <returns>A new ReactiveCommand whose CanExecute Observable is the
            current object.</returns>
        </member>
        <member name="M:ReactiveUI.Xaml.ReactiveCommandMixins.InvokeCommand``1(System.IObservable{``0},System.Windows.Input.ICommand)">
            <summary>
            A utility method that will pipe an Observable to an ICommand (i.e.
            it will first call its CanExecute with the provided value, then if
            the command can be executed, Execute() will be called)
            </summary>
            <param name="command">The command to be executed.</param>
            <returns>An object that when disposes, disconnects the Observable
            from the command.</returns>
        </member>
    </members>
</doc>
